/**
 * API请求工具函数
 */

const BASE_URL = 'http://localhost:8080'; // 后端Java API基础地址

// 添加调试日志函数
const log = (message, data) => {
    console.log(`[Request Debug] ${message}`, data);
};

// 加载状态控制
let loadingCount = 0;
const showGlobalLoading = () => {
    if (loadingCount === 0) {
        uni.showLoading({
            title: '加载中...',
            mask: true
        });
    }
    loadingCount++;
};

const hideGlobalLoading = () => {
    loadingCount--;
    if (loadingCount <= 0) {
        loadingCount = 0;
        uni.hideLoading();
    }
};

// 错误处理函数
const handleRequestError = (error) => {
    // 统一错误处理
    hideGlobalLoading();
    
    let errorMessage = '网络请求失败';
    if (error.statusCode) {
        switch (error.statusCode) {
            case 400:
                errorMessage = '请求参数错误';
                break;
            case 401:
                errorMessage = '登录已失效，请重新登录';
                console.error('[Request Debug] 认证失败:', error);
                // 清除所有认证相关的存储
                uni.removeStorageSync('token');
                uni.removeStorageSync('userRoles');
                
                // 跳转到登录页面
                setTimeout(() => {
                    uni.reLaunch({
                        url: '/pages/login/login'
                    });
                }, 1500);
                break;
            case 403:
                errorMessage = '无权限执行此操作';
                console.error('[Request Debug] 权限不足:', error);
                break;
            case 404:
                errorMessage = 'API接口不存在';
                console.error('[Request Debug] 接口不存在:', error);
                break;
            case 500:
                errorMessage = '服务器内部错误';
                console.error('[Request Debug] 服务器错误:', error);
                break;
            default:
                errorMessage = `服务器异常 (${error.statusCode})`;
                console.error('[Request Debug] 未知错误:', error);
        }
    } else if (error.message) {
        errorMessage = error.message;
        console.error('[Request Debug] 错误信息:', error);
    }
    
    // 显示错误提示
    uni.showToast({
        title: errorMessage,
        icon: 'none',
        duration: 3000
    });
    
    return Promise.reject(error);
};

// 封装请求方法
const request = (url, method, data, options = {}) => {
    // 自动显示loading
    if (options.loading !== false) {
        showGlobalLoading();
    }
    
    // 记录请求信息
    log(`开始 ${method} 请求:`, { url: BASE_URL + url, data });

    // 处理请求参数
    let finalUrl = BASE_URL + url;
    let requestData = data;
    
    // 获取token
    const token = uni.getStorageSync('token');
    
    // 如果有查询参数
    if (options.params) {
        console.log('[Request Debug] 原始查询参数:', options.params);
        
        // 确保params不是作为单个参数传递
        if (typeof options.params === 'object') {
            // 打印过滤前每个参数的值和类型
            Object.keys(options.params).forEach(key => {
                console.log(`[Request Debug] 参数 ${key} = ${options.params[key]}, 类型: ${typeof options.params[key]}, 是否为空: ${options.params[key] === ''}`);
            });
            
            const queryString = Object.keys(options.params)
                .filter(key => {
                    const include = options.params[key] != null && options.params[key] !== '';
                    console.log(`[Request Debug] 参数 ${key} 是否包含在URL中: ${include}`);
                    return include;
                })
                .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(options.params[key])}`)
                .join('&');
            
            console.log('[Request Debug] 最终查询字符串:', queryString);
            finalUrl = `${finalUrl}${finalUrl.includes('?') ? '&' : '?'}${queryString}`;
        } else {
            console.error('[Request Debug] params不是对象:', options.params);
        }
        console.log('[Request Debug] 最终URL:', finalUrl);
    }
    
    // 对于 GET 请求，将 data 转换为查询参数
    if (method === 'GET' && data && Object.keys(data).length > 0) {
        const queryString = Object.keys(data)
            .filter(key => data[key] != null && data[key] !== '')
            .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(data[key])}`)
            .join('&');
        finalUrl = `${finalUrl}${finalUrl.includes('?') ? '&' : '?'}${queryString}`;
        requestData = {}; // GET 请求不需要 body
    }
    
    return new Promise((resolve, reject) => {
        uni.request({
            url: finalUrl,
            method: method,
            data: requestData,
            header: {
                'Content-Type': 'application/json',
                'Authorization': token || ''
            },
            success: (res) => {
                log(`${method} ${url} 响应:`, res);
                console.log(`[Request Debug] 从 ${finalUrl} 收到的响应:`, res);
                
                if (res.statusCode === 200) {
                    // API响应格式 { code: 200, message: "success", data: {...} }
                    if (res.data && res.data.code === 200) {
                        if (res.data.data && res.data.data.token) {
                            // 检查token是否已包含Bearer前缀
                            const newToken = res.data.data.token;
                            uni.setStorageSync('token', newToken.startsWith('Bearer ') ? newToken : 'Bearer ' + newToken);
                        }
                        if (res.data.data && res.data.data.roles) {
                            uni.setStorageSync('userRoles', res.data.data.roles);
                        }
                        
                        // 隐藏loading
                        if (options.loading !== false) {
                            hideGlobalLoading();
                        }
                        
                        resolve(res.data);
                    } else {
                        // 业务逻辑失败
                        const errorMsg = res.data?.message || '请求失败';
                        log('业务逻辑失败:', errorMsg);
                        
                        // 隐藏loading
                        if (options.loading !== false) {
                            hideGlobalLoading();
                        }
                        
                        uni.showToast({
                            title: errorMsg,
                            icon: 'none'
                        });
                        reject(res.data);
                    }
                } else {
                    // 处理非200状态码
                    handleRequestError({
                        statusCode: res.statusCode,
                        message: res.data?.message || '请求失败',
                        response: res
                    });
                    reject({
                        statusCode: res.statusCode,
                        message: res.data?.message || '请求失败',
                        response: res
                    });
                }
            },
            fail: (err) => {
                log(`${method} ${url} 请求失败:`, err);
                handleRequestError({
                    message: '网络请求失败',
                    error: err
                });
                reject({
                    statusCode: 0,
                    message: '网络请求失败',
                    error: err
                });
            }
        });
    });
};

// 导出请求方法
export default {
    get: (url, params = {}, options = {}) => {
        return request(url, 'GET', params, options);
    },
    post: (url, data = {}, options = {}) => {
        return request(url, 'POST', data, options);
    },
    put: (url, data = {}, options = {}) => {
        return request(url, 'PUT', data, options);
    },
    delete: (url, data = {}, options = {}) => {
        return request(url, 'DELETE', data, options);
    }
}; 